Fix warnings for constant names

diff --git a/src/bin/cargo.rs b/src/bin/cargo.rs
index 4f52d482d963c2f879457e3b5ea595f900c82cd0..5f7e3f352536692d78e48b7413666e32b0bbeb5e 100644 (file)
--- a/src/bin/cargo.rs
+++ b/src/bin/cargo.rs
@@ -187,7 +187,7 @@ fn list_commands() -> TreeSet<String> {
 fn is_executable(path: &Path) -> bool {
     match fs::stat(path) {
         Ok(io::FileStat{ kind: io::TypeFile, perm, ..}) =>
-            perm.contains(io::OtherExecute),
+            perm.contains(io::OTHER_EXECUTE),
         _ => false
     }
 }

diff --git a/src/cargo/ops/cargo_new.rs b/src/cargo/ops/cargo_new.rs
index b43b735d5161123e534d544995a6094e3e346577..79191ecaa1f93f49d356b3f4ddf2f0e0f6c78255 100644 (file)
--- a/src/cargo/ops/cargo_new.rs
+++ b/src/cargo/ops/cargo_new.rs
@@ -46,7 +46,7 @@ fn mk(path: &Path, name: &str, opts: &NewOptions) -> CargoResult<()> {
         try!(HgRepo::init(path));
         try!(File::create(&path.join(".hgignore")).write(ignore.as_bytes()));
     } else if !opts.git && (opts.no_git || cfg.git == Some(false)) {
-        try!(fs::mkdir(path, io::UserRWX));
+        try!(fs::mkdir(path, io::USER_RWX));
     } else {
         try!(GitRepo::init(path));
         try!(File::create(&path.join(".gitignore")).write(ignore.as_bytes()));
@@ -75,7 +75,7 @@ version = "0.0.1"
 authors = ["{}"]
 "#, name, author).as_slice()));
 
-    try!(fs::mkdir(&path.join("src"), io::UserRWX));
+    try!(fs::mkdir(&path.join("src"), io::USER_RWX));
 
     if opts.bin {
         try!(File::create(&path.join("src/main.rs")).write_str("\

diff --git a/src/cargo/ops/cargo_rustc/fingerprint.rs b/src/cargo/ops/cargo_rustc/fingerprint.rs
index 9accddf6602d459cc441fa14498bb3fe23a58c49..3846034da090e00c225295bb892ecbc76bf54562 100644 (file)
--- a/src/cargo/ops/cargo_rustc/fingerprint.rs
+++ b/src/cargo/ops/cargo_rustc/fingerprint.rs
@@ -1,7 +1,7 @@
 use std::collections::hashmap::{Occupied, Vacant};
 use std::hash::{Hash, Hasher};
 use std::hash::sip::SipHasher;
-use std::io::{fs, File, UserRWX, BufferedReader};
+use std::io::{fs, File, USER_RWX, BufferedReader};
 
 use core::{Package, Target, PathKind};
 use util;
@@ -166,8 +166,8 @@ pub fn prepare_init(cx: &mut Context, pkg: &Package, kind: Kind)
     let (_, new1) = dirs(cx, pkg, kind);
     let new2 = new1.clone();
 
-    let work1 = proc() { try!(fs::mkdir(&new1, UserRWX)); Ok(()) };
-    let work2 = proc() { try!(fs::mkdir(&new2, UserRWX)); Ok(()) };
+    let work1 = proc() { try!(fs::mkdir(&new1, USER_RWX)); Ok(()) };
+    let work2 = proc() { try!(fs::mkdir(&new2, USER_RWX)); Ok(()) };
 
     (work1, work2)
 }

diff --git a/src/cargo/ops/cargo_rustc/layout.rs b/src/cargo/ops/cargo_rustc/layout.rs
index 82397d3f5286d4ff76763a31a94af48d6f51c788..a9e9ca29473e09935bdbf11932ebf864b65be8ae 100644 (file)
--- a/src/cargo/ops/cargo_rustc/layout.rs
+++ b/src/cargo/ops/cargo_rustc/layout.rs
@@ -98,7 +98,7 @@ impl Layout {
 
     pub fn prepare(&mut self) -> IoResult<()> {
         if !self.root.exists() {
-            try!(fs::mkdir_recursive(&self.root, io::UserRWX));
+            try!(fs::mkdir_recursive(&self.root, io::USER_RWX));
         }
 
         if self.old_deps.exists() {
@@ -123,10 +123,10 @@ impl Layout {
             try!(fs::rename(&self.fingerprint, &self.old_fingerprint));
         }
 
-        try!(fs::mkdir(&self.deps, io::UserRWX));
-        try!(fs::mkdir(&self.native, io::UserRWX));
-        try!(fs::mkdir(&self.fingerprint, io::UserRWX));
-        try!(fs::mkdir(&self.old_root, io::UserRWX));
+        try!(fs::mkdir(&self.deps, io::USER_RWX));
+        try!(fs::mkdir(&self.native, io::USER_RWX));
+        try!(fs::mkdir(&self.fingerprint, io::USER_RWX));
+        try!(fs::mkdir(&self.old_root, io::USER_RWX));
 
         for file in try!(fs::readdir(&self.root)).iter() {
             if !file.is_file() { continue }

diff --git a/src/cargo/ops/cargo_rustc/mod.rs b/src/cargo/ops/cargo_rustc/mod.rs
index f1428c57ede1b462016ae1ba66eb9e1dbf4db579..64360f910d2952d86b9336a87597f21901556c5e 100644 (file)
--- a/src/cargo/ops/cargo_rustc/mod.rs
+++ b/src/cargo/ops/cargo_rustc/mod.rs
@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 use std::dynamic_lib::DynamicLibrary;
-use std::io::{fs, UserRWX};
+use std::io::{fs, USER_RWX};
 use std::io::fs::PathExtensions;
 use std::os;
 
@@ -232,7 +232,7 @@ fn compile_custom(pkg: &Package, cmd: &str,
             try!(if old_output.exists() {
                 fs::rename(&old_output, &output)
             } else {
-                fs::mkdir(&output, UserRWX)
+                fs::mkdir(&output, USER_RWX)
             }.chain_error(|| {
                 internal("failed to create output directory for build command")
             }));

diff --git a/src/cargo/sources/git/utils.rs b/src/cargo/sources/git/utils.rs
index 03919f45d7d11a10d92cbf36b276ca996b2c7106..3e75d8a8baac59678b33d4707c33af401c7cf0ba 100644 (file)
--- a/src/cargo/sources/git/utils.rs
+++ b/src/cargo/sources/git/utils.rs
@@ -1,5 +1,5 @@
 use std::fmt::{mod, Show, Formatter};
-use std::io::{UserDir};
+use std::io::{USER_DIR};
 use std::io::fs::{mkdir_recursive, rmdir_recursive, PathExtensions};
 use serialize::{Encodable, Encoder};
 use url::Url;
@@ -183,7 +183,7 @@ impl GitRemote {
         if dst.exists() {
             try!(rmdir_recursive(dst));
         }
-        try!(mkdir_recursive(dst, UserDir));
+        try!(mkdir_recursive(dst, USER_DIR));
         let repo = try!(git2::Repository::init_bare(dst));
         try!(fetch(&repo, url.as_slice(), "refs/heads/*:refs/heads/*"));
         Ok(repo)
@@ -256,7 +256,7 @@ impl<'a> GitCheckout<'a> {
     fn clone_repo(source: &Path, into: &Path) -> CargoResult<git2::Repository> {
         let dirname = into.dir_path();
 
-        try!(mkdir_recursive(&dirname, UserDir).chain_error(|| {
+        try!(mkdir_recursive(&dirname, USER_DIR).chain_error(|| {
             human(format!("Couldn't mkdir {}", dirname.display()))
         }));
 

diff --git a/src/cargo/sources/registry.rs b/src/cargo/sources/registry.rs
index 9ce586d4b4cc1619d503333935298bf10d2bdee3..9165d50b7696a166914977a5163bb21654d1ad4d 100644 (file)
--- a/src/cargo/sources/registry.rs
+++ b/src/cargo/sources/registry.rs
@@ -94,7 +94,7 @@ impl<'a, 'b> RegistrySource<'a, 'b> {
             Err(..) => {}
         }
 
-        try!(fs::mkdir_recursive(&self.checkout_path, io::UserDir));
+        try!(fs::mkdir_recursive(&self.checkout_path, io::USER_DIR));
         let _ = fs::rmdir_recursive(&self.checkout_path);
         let repo = try!(git2::Repository::init(&self.checkout_path));
         Ok(repo)
@@ -114,7 +114,7 @@ impl<'a, 'b> RegistrySource<'a, 'b> {
         if dst.exists() { return Ok(dst) }
         try!(self.config.shell().status("Downloading", pkg));
 
-        try!(fs::mkdir_recursive(&dst.dir_path(), io::UserDir));
+        try!(fs::mkdir_recursive(&dst.dir_path(), io::USER_DIR));
         let handle = match self.handle {
             Some(ref mut handle) => handle,
             None => {
@@ -159,7 +159,7 @@ impl<'a, 'b> RegistrySource<'a, 'b> {
                                              pkg.get_version()));
         if dst.join(".cargo-ok").exists() { return Ok(dst) }
 
-        try!(fs::mkdir_recursive(&dst.dir_path(), io::UserDir));
+        try!(fs::mkdir_recursive(&dst.dir_path(), io::USER_DIR));
         let f = try!(File::open(&tarball));
         let mut gz = try!(GzDecoder::new(f));
         // TODO: don't read into memory (Archive requires Seek)
@@ -168,7 +168,7 @@ impl<'a, 'b> RegistrySource<'a, 'b> {
         for file in try!(tar.files()) {
             let mut file = try!(file);
             let dst = dst.dir_path().join(file.filename_bytes());
-            try!(fs::mkdir_recursive(&dst.dir_path(), io::UserDir));
+            try!(fs::mkdir_recursive(&dst.dir_path(), io::USER_DIR));
             let mut dst = try!(File::create(&dst));
             try!(io::util::copy(&mut file, &mut dst));
         }

diff --git a/tests/support/git.rs b/tests/support/git.rs
index 010b1da7af220498a110dae133cc551cd81fe90b..4d9bfacb8c810ce3cc61e4d5615fb1c13fbb1b46 100644 (file)
--- a/tests/support/git.rs
+++ b/tests/support/git.rs
@@ -11,7 +11,7 @@ pub fn repo(p: &Path) -> RepoBuilder { RepoBuilder::init(p) }
 
 impl RepoBuilder {
     pub fn init(p: &Path) -> RepoBuilder {
-        fs::mkdir_recursive(&p.dir_path(), io::UserDir).unwrap();
+        fs::mkdir_recursive(&p.dir_path(), io::USER_DIR).unwrap();
         let repo = git2::Repository::init(p).unwrap();
         {
             let mut config = repo.config().unwrap();
@@ -30,7 +30,7 @@ impl RepoBuilder {
     pub fn nocommit_file<T: Str>(self, path: &str,
                                  contents: T) -> RepoBuilder {
         let dst = self.repo.path().dir_path().join(path);
-        fs::mkdir_recursive(&dst.dir_path(), io::UserDir).unwrap();
+        fs::mkdir_recursive(&dst.dir_path(), io::USER_DIR).unwrap();
         File::create(&dst).write_str(contents.as_slice()).unwrap();
         self
     }

diff --git a/tests/support/mod.rs b/tests/support/mod.rs
index 5eafd281c45179949c8eb75810cbba2592da3760..4b3ecf9d3ff794481e85eff5dc35f2c8c4a5d220 100644 (file)
--- a/tests/support/mod.rs
+++ b/tests/support/mod.rs
@@ -183,7 +183,7 @@ pub fn project(name: &str) -> ProjectBuilder {
 // === Helpers ===
 
 pub fn mkdir_recursive(path: &Path) -> Result<(), String> {
-    fs::mkdir_recursive(path, io::UserDir)
+    fs::mkdir_recursive(path, io::USER_DIR)
         .with_err_msg(format!("could not create directory; path={}",
                               path.display()))
 }

diff --git a/tests/support/paths.rs b/tests/support/paths.rs
index 126fafeaf754a3c8f2f4dc9cb287ed41d6d467f2..97ac8262e7b4f0a7eac05c33061de9d39bdaed3c 100644 (file)
--- a/tests/support/paths.rs
+++ b/tests/support/paths.rs
@@ -48,7 +48,7 @@ impl PathExt for Path {
                 e => return e,
             }
             for path in try!(fs::walk_dir(self)) {
-                try!(fs::chmod(&path, io::UserRWX));
+                try!(fs::chmod(&path, io::USER_RWX));
             }
             fs::rmdir_recursive(self)
         } else {
@@ -57,7 +57,7 @@ impl PathExt for Path {
     }
 
     fn mkdir_p(&self) -> IoResult<()> {
-        fs::mkdir_recursive(self, io::UserDir)
+        fs::mkdir_recursive(self, io::USER_DIR)
     }
 
     fn move_into_the_past(&self) -> IoResult<()> {
@@ -83,7 +83,7 @@ impl PathExt for Path {
                 Err(io::IoError { kind: io::PermissionDenied, .. }) => {}
                 e => return e,
             }
-            try!(fs::chmod(path, stat.perm | io::UserWrite));
+            try!(fs::chmod(path, stat.perm | io::USER_WRITE));
             fs::change_file_times(path, newtime, newtime)
         }
     }

diff --git a/tests/test_cargo.rs b/tests/test_cargo.rs
index a4ce15a981f6cc2dd85815b54edb5dab3ea4cfb2..6db2f77fa48e597ab24dc94da927f280529b48a8 100644 (file)
--- a/tests/test_cargo.rs
+++ b/tests/test_cargo.rs
@@ -17,7 +17,7 @@ fn fake_executable(proj: ProjectBuilder, dir: &Path, name: &str) -> ProjectBuild
     mkdir_recursive(&Path::new(path.dirname())).assert();
     fs::File::create(&path).assert();
     let io::FileStat{perm, ..} = fs::stat(&path).assert();
-    fs::chmod(&path, io::OtherExecute | perm).assert();
+    fs::chmod(&path, io::OTHER_EXECUTE | perm).assert();
     proj
 }
 

diff --git a/tests/test_cargo_compile_path_deps.rs b/tests/test_cargo_compile_path_deps.rs
index 2723455750e45b3ab107b9c9a6d3b5f458221fb4..58c30f820b99bd963b3dabd18e584b0c447d147f 100644 (file)
--- a/tests/test_cargo_compile_path_deps.rs
+++ b/tests/test_cargo_compile_path_deps.rs
@@ -1,4 +1,4 @@
-use std::io::{fs, File, UserRWX};
+use std::io::{fs, File, USER_RWX};
 
 use support::{ResultTest, project, execs, main_file, cargo_dir};
 use support::{COMPILING, RUNNING};
@@ -527,7 +527,7 @@ test!(override_relative {
         "#)
        .file("src/lib.rs", "");
 
-    fs::mkdir(&paths::root().join(".cargo"), UserRWX).assert();
+    fs::mkdir(&paths::root().join(".cargo"), USER_RWX).assert();
     File::create(&paths::root().join(".cargo/config")).write_str(r#"
         paths = ["bar"]
     "#).assert();

diff --git a/tests/test_cargo_new.rs b/tests/test_cargo_new.rs
index bd25aab41a52cbc5dab7b33d4a9926e9cc1aa091..58b5c99a91bdb35e375ae7d3c96598993d98b691 100644 (file)
--- a/tests/test_cargo_new.rs
+++ b/tests/test_cargo_new.rs
@@ -1,4 +1,4 @@
-use std::io::{fs, UserRWX, File, TempDir};
+use std::io::{fs, USER_RWX, File, TempDir};
 use std::io::fs::PathExtensions;
 use std::os;
 
@@ -93,7 +93,7 @@ Usage:
 
 test!(existing {
     let dst = paths::root().join("foo");
-    fs::mkdir(&dst, UserRWX).assert();
+    fs::mkdir(&dst, USER_RWX).assert();
     assert_that(cargo_process("new").arg("foo"),
                 execs().with_status(101)
                        .with_stderr(format!("Destination `{}` already exists\n",
@@ -132,7 +132,7 @@ test!(author_prefers_cargo {
     my_process("git").args(["config", "--global", "user.email", "baz"])
                      .exec().assert();
     let root = paths::root();
-    fs::mkdir(&root.join(".cargo"), UserRWX).assert();
+    fs::mkdir(&root.join(".cargo"), USER_RWX).assert();
     File::create(&root.join(".cargo/config")).write_str(r#"
         [cargo-new]
         name = "new-foo"
@@ -151,7 +151,7 @@ test!(author_prefers_cargo {
 
 test!(git_prefers_command_line {
     let root = paths::root();
-    fs::mkdir(&root.join(".cargo"), UserRWX).assert();
+    fs::mkdir(&root.join(".cargo"), USER_RWX).assert();
     File::create(&root.join(".cargo/config")).write_str(r#"
         [cargo-new]
         git = false

diff --git a/tests/test_cargo_registry.rs b/tests/test_cargo_registry.rs
index 37342a5735898afdd6a4df8b9ea675a808ab4c77..3101d05b76dc66dc3d5d8440120d1184eef4fb10 100644 (file)
--- a/tests/test_cargo_registry.rs
+++ b/tests/test_cargo_registry.rs
@@ -24,7 +24,7 @@ fn cksum(s: &[u8]) -> String {
 
 fn setup() {
     let config = paths::root().join(".cargo/config");
-    fs::mkdir_recursive(&config.dir_path(), io::UserDir).assert();
+    fs::mkdir_recursive(&config.dir_path(), io::USER_DIR).assert();
     File::create(&config).write_str(format!(r#"
         [registry]
             host = "{reg}"
@@ -62,7 +62,7 @@ fn setup() {
     }
     fn dl(path: &str, contents: &[u8]) -> String {
         let dst = dl_path().join(path);
-        fs::mkdir_recursive(&dst.dir_path(), io::UserDir).assert();
+        fs::mkdir_recursive(&dst.dir_path(), io::USER_DIR).assert();
         File::create(&dst).write(contents).unwrap();
         cksum(contents)
     }

diff --git a/tests/test_cargo_upload.rs b/tests/test_cargo_upload.rs
index a813ef080c046723efd276b06bb22e7cf653ad47..7ad46c7cb3cbfd7b6935fa7e03ce0b26ce21bcfe 100644 (file)
--- a/tests/test_cargo_upload.rs
+++ b/tests/test_cargo_upload.rs
@@ -18,7 +18,7 @@ fn upload() -> Url { Url::from_file_path(&upload_path()).unwrap() }
 
 fn setup() {
     let config = paths::root().join(".cargo/config");
-    fs::mkdir_recursive(&config.dir_path(), io::UserDir).assert();
+    fs::mkdir_recursive(&config.dir_path(), io::USER_DIR).assert();
     File::create(&config).write_str(format!(r#"
         [registry]
             host = "{reg}"